内存

xmp

近日发现自己3000mhz的内存条在资源管理器里面显示只有2133mhz

原来是因为xmp没开

参考文献

单词

颜色标记

红色，生词

绿色，疏意

100个句子记完5500个考研单词

Sentence 01

We become defensive when criticised, and apply negative $\color{red}{\text{stereotypes}}$ to others to boost our own $\color{red}{\text{esteem}}$.

一旦受到批评，我们就会为自己辩护，并将他人定格为消极的老套形 象，以此增强自己的自尊心。

Sentence 02

Devoted $\color{green}{\text{concertgoers}}$ who reply that recordings are no substitute for live performance are missing the point.

那些忠诚的$\color{green}{\text{音乐会听众}}$回应说现场演出绝非是唱片所能替代的，可这些听众没有领会到问题的关键点。

Sentence 03

Ants keep $\color{red}{\text{predatory}}$ insects away from where their $\color{red}{\text{aphids}}$ feed; Gmail keeps the $\color{red}{\text{spammers}}$ out of our inboxes.

蚂蚁让$\color{red}{\text{食肉昆虫}}$远离$\color{red}{\text{蚜虫}}$进食的地方；谷歌邮箱让$\color{red}{\text{滥发垃圾邮件的人}}$远离我们的收件箱。

Sentence 04

At the same time, people continue to treat fire as an event that needs to be wholly controlled and $\color{red}{\text{unleashed}}$ only out of necessity.

与此同时，人们继续把用火视为一种需要全面控制的事件，只有在必要之时才$\color{red}{\text{放出来}}$使用。

Sentence 05

As boards $\color{red}{\text{scrutinize}}$ succession plans in response to shareholder pressure, executives who don’t get the nod also may wish to move on.

在董事会迫于股东的压力严格$\color{red}{\text{审查}}$继任计划的时候，那些没被选中的高管们也可能想离开。

Sentence 06

Everyone needs to find their extra—their unique value contribution that makes them stand out in whatever is their field of employment.

人人都需要找到自己的额外价值——让自己在任何所在$\color{green}{\text{职业领域}}$中都脱颖而出的独特价值贡献。

Sentence 07

It is also the reason why when we try to describe music with words, all we can do is $\color{red}{\text{articulate}}$ our reactions to it, and not grasp music itself.

这也是为什么当我们试图用语言来描述音乐时，我们所能做的只能是$\color{red}{\text{说清楚}}$对音乐的感受，而不能理解音乐本身。

Sentence 08

Scientists jumped to the rescue with some distinctly $\color{red}{\text{shaky}}$ evidence to $\color{green}{\text{the effect}}$ that insects would eat us up if birds failed to control them.

科学家们立即拿出某些明显$\color{red}{\text{站不住脚}}$的证据前来“救驾”，其大意是说如果鸟儿不能控制这些昆虫的数量的话，昆虫就会吃光一切。(the effect 后果)

Sentence 09

A moralist, satirist, and social reformer, Dickens crafted complex plots and $\color{red}{\text{striking}}$ characters that capture the $\color{red}{\text{panorama}}$ of English society.

作为一位道德家、讽刺作家和社会改革家，狄更斯精心设计了复杂的情节和$\color{red}{\text{引人注目}}$的人物，捕捉了英国社会的$\color{red}{\text{全貌}}$。

Sentence 10

Half a century of town and country planning has enabled it to $\color{red}{\text{retain}}$ an enviable rural $\color{red}{\text{coherence}}$, while still permitting low-density urban living.

半个世纪的城乡规划使其（英国）得以$\color{red}{\text{保留}}$令人羡慕的乡村$\color{red}{\text{和谐}}$，同时仍允许低密度的城镇生活。

Sentence 11

$\color{red}{\text{Integrity}}$ had collapsed, she argued, because of a collective acceptance that the only “sorting mechanism” in society should be profit and the market.

她认为，$\color{red}{\text{诚信}}$已瓦解，因为我们集体接受的观念是，社会中唯一的“分选机制”应该是利润和市场。

Sentence 12

We need them to imagine the United States as a place where they can be productive for a while without committing themselves to staying forever.

我们需要他们把美国想象为这样一个地方，在这里他们可以在一段时间内创造价值，而无需承诺永久居留于此。

Sentence 13

The $\color{green}{\text{issue}}$ of $\color{green}{\text{voluntary part-time}}$ relates to $\color{red}{\text{Obamacare}}$ because one of the main purposes was to allow people to get insurance $\color{green}{\text{outside of employment}}$.

$\color{green}{\text{自愿兼职工作}}$这一$\color{green}{\text{问题}}$与奥巴马医改计划相关联，因为该计划的主要目的之一就是让人们$\color{green}{\text{不就业}}$也能得到医疗保险。

Sentence 14

Firms are now studying how genes interact, looking for $\color{green}{\text{correlations}}$ that might be used to determine the causes of disease or predict a drug’s $\color{green}{\text{efficacy}}$.

一些公司正在研究基因是如何相互作用的，寻找可能用来确定病因或者预测药物$\color{green}{\text{疗效}}$的$\color{green}{\text{相关性}}$。

Sentence 15

$\color{green}{\text{Dead markets}}$ partly reflect the $\color{green}{\text{paralysis}}$ of banks which will not sell assets for fear of $\color{green}{\text{booking losses}}$, yet are reluctant to buy all those $\color{green}{\text{supposed bargains}}$.

$\color{green}{\text{毫无活力的市场}}$一定程度上反映了银行系统的$\color{green}{\text{瘫痪}}$，由于担心$\color{green}{\text{账面损失}}$，银行不会出售资产，但也不愿意收购那些所谓的$\color{green}{\text{廉价资产}}$。

Sentence 16

He adds $\color{red}{\text{humbly}}$ that perhaps he was “superior to the $\color{green}{\text{common run of men}}$ in noticing things which easily escape attention, and in observing them carefully”.

他$\color{red}{\text{谦虚地}}$补充道，或许他“优于$\color{green}{\text{常人}}$的地方在于能够注意到容易被忽视的东西，并对这些东西进行仔细观察”。

Sentence 17

Many leading American universities want their undergraduates to have a $\color{red}{\text{grounding}}$ in the basic $\color{red}{\text{canon}}$ of ideas that every educated person should $\color{green}{\text{possess}}$.

许多顶尖的美国大学都希望他们的本科生接受对一些基本的、富含思想的经典作品的$\color{red}{\text{基础教学}}$，这些思想是每个受教育人士都$\color{green}{\text{应该有}}$的。($\color{red}{\text{canon}}$:原则)

• 研究生 postgraduate
• 硕士 master
• 博士 doctor
• 学士 bachelor
• 博士后 post doctor

Sentence 18

Buying gifts or giving to charity is often more pleasurable than purchasing things for oneself, and luxuries are most enjoyable when they are consumed $\color{red}}{\text{sparingly}}$.

买礼物或给慈善机构捐款往往会比给自己买东西更让人开心，$\color{red}{\text{有节制地}}$消费奢侈品才会给人以最大的愉悦。

Sentence 19

These $\color{red}{\text{benefactors}}$ have succeeded in their chosen fields, they say, and they want to use their wealth to draw attention to those who have succeeded in science.

他们说，这些$\color{red}{\text{捐助者}}$在各自所选择的领域都很成功，而且他们想用自己的财富让人们注意到那些在科学领域有所成就的人。

Sentence 20

Perhaps $\color{red}{\text{faintly}}$, they hint that people should look to $\color{red}{\text{intangible}}$ qualities like character and intellect rather than $\color{green}{\text{dieting their way}}$ to $\color{green}{\text{size zero}}$ or $\color{red}{\text{wasp}}$-$\color{red}{\text{waist}}$ $\color{red}{\text{physiques}}$.

这些禁令或许还$\color{red}{\text{隐约地}}$暗示，人们应该注重如个性和才智等$\color{red}{\text{无形}}$的品质，而不是$\color{green}{\text{通过节食}}$来达到“$\color{green}{\text{零号身材}}$”或“$\color{red}{\text{蜂}}$ $\color{red}{\text{腰}}$ $\color{red}{\text{体型}}$”。

Sentence 21

The Navy Department moved into the $\color{green}{\text{east wing}}$ in 1879, where $\color{red}{\text{elaborate}}$ wall and ceiling $\color{red}{\text{stenciling}}$ and $\color{red}{\text{marquetry}}$ floors decorated the office of the $\color{green}{\text{Secretary}}$.

海军部门于1879年搬进了$\color{green}{\text{东翼}}$，在那里，$\color{red}{\text{精心制作}}$的墙壁、天花板上的$\color{red}{\text{镂花涂装}}$和$\color{red}{\text{镶嵌工艺}}$地板装饰着$\color{green}{\text{部长}}$办公室。

Sentence 22

The researchers mapped not only the city’s vast and $\color{red}{\text{ornate}}$ $\color{green}{\text{ceremonial areas}}$, but also hundreds of simpler $\color{green}{\text{apartment complexes}}$ where common people lived.

研究人员不仅绘制了这座城市广阔且$\color{red}{\text{装饰华丽}}$的$\color{green}{\text{庆典区}}$，还绘制了数百个普通民众居住的简单公寓$\color{green}{\text{建筑群}}$。

Sentence 23

It may be said that the measure of the worth of any social institution is its effect in enlarging and improving $\color{green}{\text{experience}}$, but this effect is not a part of its $\color{green}{\text{original motive}}$.

可以说，衡量任何社会制度价值的标准是其在扩大和改进$\color{green}{\text{经验}}$上的成效，但这种成效并不是其$\color{green}{\text{最初动机}}$的一部分。

Sentence 24

Our mental health doesn’t really $\color{green}{\text{go anywhere}}$; like the sun behind a cloud, it can be temporarily hidden from view, but it is fully capable of being restored in an instant.

我们的心理健康并不是真的$\color{green}{\text{消失不见}}$了；就像云朵背后的太阳，它也许暂时被遮挡，但是它完全可以在瞬间重焕光芒。

Sentence 25

No boy who went to a grammar school could be ignorant that the drama was a form of literature which gave glory to Greece and Rome and might yet bring honor to England.

每个进入文法学校学习的学生都知道，戏剧是一种文学形式，这种文学形式赋予希腊和罗马以荣光，并且可能也会为英国带来荣耀。

Sentence 26

The most loyal customers would still get the product they favor, the idea goes, and they’d feel like they were helping $\color{green}{\text{sustain}}$ the quality of something they believe in.

这个想法是这样：那些最忠诚的顾客依旧会购买他们喜欢的产品，他们会觉得这是在帮助$\color{green}{\text{维护}}$他们所信任的产品的品质。

Sentence 27

But policymakers who refocus efforts on $\color{green}{\text{improving well-being}}$ rather than simply worrying about GDP figures could avoid the forecasted $\color{green}{\text{doom}}$ and may even see progress.

但是那些重新致力于$\color{green}{\text{改善福祉}}$，而不仅仅是担心国内生产总值数据的决策者们，就能够避免可预见的$\color{green}{\text{厄运}}$，甚至可能看到进步。

Sentence 28

Indeed, there is something a little $\color{green}{\text{absurd}}$ in the state getting involved in the planning of such a fundamentally “grassroots” concept $\color{green}{\text{as}}$ community sports associations.

确实，让国家参与$\color{green}{\text{像}}$社区体育协会这样从根本上带有“草根阶层”意味的规划是有些$\color{green}{\text{荒唐}}$的。

Sentence 29

While few $\color{green}{\text{craftsmen}}$ or farmers, let alone $\color{green}{\text{dependents}}$ and servants, left $\color{green}{\text{literary compositions}}$ to be analyzed, it is obvious that their views were less fully $\color{green}{\text{intellectualized}}$.

尽管很少有$\color{green}{\text{工匠}}$或农场主能留下可供分析的文学作品，更不用说他们的随从和佣人了，但很明显他们的观点并不十分$\color{green}{\text{理性}}$。

Sentence 30

While comment and reaction from lawyers may enhance $\color{green}{\text{stories}}$, it is preferable for journalists to rely on their own notions of significance and make their own judgments.

尽管来自律师们的评论和反馈可能会提高$\color{green}{\text{新闻报道}}$的质量，但新闻记者最好还是依靠自己对事件重要性的认识而做出自己的判断。

Sentence 31

Social media allows users to experience news events more $\color{green}{\text{intimately}}$ and immediately while also permitting them to re-share news as a projection of their values and interests.

社交媒体允许用户$\color{green}{\text{更密切}}$、更迅速地体验新闻事件，同时也允许他们将新闻作为自己价值观和兴趣的投射而重新分享。

Sentence 32

According to research from Princeton University, people $\color{green}{\text{assess}}$ your $\color{green}{\text{competence}}$, $\color{green}{\text{trustworthiness}}$, and $\color{green}{\text{likeability}}$ in just $\color{green}{\text{a tenth of a second}}$, $\color{green}{\text{solely}}$ based on the way you look.

根据普林斯顿大学的研究，人们会在仅仅$\color{green}{\text{十分之一秒}}$的时间内，$\color{green}{\text{仅}}$根据你的外表去$\color{green}{\text{评判}}$你的$\color{green}{\text{能力}}$、$\color{green}{\text{可信度}}$及你$\color{green}{\text{受人喜欢的程度}}$。

Sentence 33

Some $\color{green}{\text{attributed}}$ virtually every important cultural achievement $\color{green}{\text{to}}$ the inventions of a few, especially gifted peoples that, according to $\color{red}{\text{diffusionists}}$, then spread to other cultures.

有些人$\color{green}{\text{认为}}$，几乎每一项重要的文化成就都是由少数特别有天赋的民族所发明创造的，根据$\color{red}{\text{传播论者}}$的看法，这些发明后来传播到了其他的文化中。

Sentence 34

The $\color{green}{\text{upside}}$ is the possibilities $\color{green}{\text{contained in}}$ knowing that everything is up to us; where before we were $\color{green}{\text{experts in}}$ the array of limitations, now we become $\color{green}{\text{authorities}}$ of what is possible.

积极的一面是，既然万事都取决于我们，那么就有无限可能。以前，我们能够$\color{green}{\text{熟练应对}}$种种局限；现在，我们$\color{green}{\text{把握着}}$未来的可能。

• contained in = because

Sentence 35

If people in the network just two $\color{green}{\text{degrees}}$ removed from the initial influential prove $\color{red}{\text{resistant}}$, $\color{green}{\text{for example}}$, the $\color{red}{\text{cascade}}$ of change won’t $\color{red}{\text{propagate}}$ very far or affect many people.

例如，如果在这一社交网络中与最初的影响者存在$\color{green}{\text{两个层级}}$的人们表现出$\color{red}{\text{抵制}}$的话，$\color{green}{\text{那么}}$这$\color{red}{\text{一连串}}$的变化就不会$\color{red}{\text{传播}}$很远或影响许多人。

• remove 和 in 同义？

Sentence 36

In a workplace that’s fundamentally indifferent to your life and its meaning, office speak can help you figure out how you relate to your work—and how your work defines who you are.

在一个根本不关心你的生活及其意义的职场中，办公室用语能帮助你理清自己和工作的关系，以及工作对你的身份的定义。

Sentence 37

Conversations are links, which means when you have a conversation with a new person a link gets formed and every conversation you have after that moment will strengthen the link.

交谈是一种联系，这意味着当你和一个刚认识的人交谈时，一种联系就形成了，而在那之后的每一次交谈都会强化这一联系。

Sentence 38

Researchers measured people’s cortisol, which is a stress marker, while they were at work and while they were at home and found it higher at what is supposed to be a place of refuge.

研究人员测量了人们在工作和在家时的皮质醇，它是一种压力标志，并发现在家这个理应是庇护所的地方，人们的皮质醇水平更高。

Sentence 39

While Washington and Jefferson privately expressed distaste for slavery, they also understood that it was part of the political and economic bedrock of the country they helped to create.

尽管华盛顿和杰斐逊私下都表达过对奴隶制的不满，但是他们也明白，奴隶制是他们帮助创建的这个国家的政治和经济基础的一部分。

Sentence 40

When younger kids learn computer science, they learn that it’s not just a confusing, endless string of letters and numbers—but a tool to build apps, or create artwork, or test hypotheses.

当小孩子们学习计算机科学的时候，他们会发现它并不仅仅是一串令人困惑的、无穷无尽的字母和数字——它还是一种工具，这种工具能编写应用程序、创作艺术作品或测试假设。

Sentence 41

The Industrial Revolution didn’t go so well for Luddites whose jobs were displaced by mechanized looms, but it eventually raised living standards and created more jobs than it destroyed.

尽管工业革命在工作被机械化织布机取代的卢德派分子中进展并不顺利，但它最终提高了生活水平，并创造了比被它摧毁的工作岗位更多的就业机会。

Sentence 42

That ruling produced an explosion in business-method patent filings, initially by emerging internet companies trying to stake out exclusive rights to specific types of online transactions.

那项裁决使得商业方法专利申请文件数量激增，起初只是一些新兴的网络公司试图抢占对某些特定类型的在线交易方法的独家专有权。

Sentence 43

Even though there is plenty of evidence that the quality of the teachers is the most important variable, teachers’ unions have fought against getting rid of bad ones and promoting good ones.

虽然有充分的证据表明，教师素质是最重要的可变因素，但是教师工会却反对开除差教师、提拔好教师。

Sentence 44

Yet most ancestry testing only considers a single lineage, either the Y chromosome inherited through men in a father’s line or mitochondrial DNA, which is passed down only from mothers.

然而，大多数血统检测只考虑单一的血统，要么只考虑来自父亲的男性遗传的Y染色体，要么只考虑从母亲那里遗传的线粒体DNA。

Sentence 45

Moreover, even though humans have been upright for millions of years, our feet and back continue to struggle with bipedal posture and cannot easily withstand repeated strain imposed by oversize limbs.

此外，尽管人类直立行走已达数百万年之久，但是我们的双脚和背部仍然在与两足行走的姿势作斗争，并且很难承受过长的四肢施加的持续压力。

Sentence 46

While the researchers assumed that the well-structured daily plans would be most effective when it came to the execution of tasks, they were wrong: the detailed daily plans demotivated students.

尽管研究人员认为，在执行任务时，详尽的每日目标是最为高效的，但他们错了，详细的每日计划使学生失去了动力。

Sentence 47

While fossil fuels—coal, oil, gas—still generate roughly 85 percent of the world’s energy supply, it’s clearer than ever that the future belongs to renewable sources such as wind and solar.

虽然化石燃料——煤、石油、天然气——仍然占据世界能源供应的85%左右，但比以往任何时候都更明显的是，未来属于风能和太阳能等可再生能源。

Sentence 48

Only if the jobless arrive at the jobcentre with a CV, register for online job search, and start looking for work will they be eligible for benefit—and then they should report weekly rather than fortnightly.

只有当失业者带着简历来到就业服务中心，注册在线求职，并开始寻找工作，他们才有资格获得补助金，然后他们应该每周而不是每两周汇报一次求职情况。

Sentence 49

It is not that pink is intrinsically bad, but it is such a tiny slice of the rainbow and, though it may celebrate girlhood in one way, it also repeatedly and firmly fuses girls’ identity to appearance.

究其本质，粉红色本身并没有什么不好，它只不过是彩虹上微小的一抹。虽然从某种程度上来说它歌颂了少女时代，但它也反复且坚定地把女孩的个性和外表融合起来。

Sentence 50

Here, Darwinism seems to offer justification, for if all humans share common origins, it seems reasonable to suppose that cultural diversity could also be traced to more constrained beginnings.

在此，达尔文学说似乎给出了合理化的解释，这是因为如果整个人类有相同的起源，那么我们就有理由认为，文化多样性同样也可以追溯到更为有限的开端。

Sentence 51

If you are working on a word processor, you can take advantage of its capacity to make additions and deletions as well as move entire paragraphs by making just a few simple keyboard commands.

如果你正借助文字处理软件进行工作，只需通过几个简单的键盘指令，你就可以利用它来进行删减、增加或移动整段文字。

Sentence 52

This success, coupled with later research showing that memory itself is not genetically determined, led Ericsson to conclude that the act of memorizing is more of a cognitive exercise than an intuitive one.

这次的成功，加上后来表明记忆本身不由基因决定的研究，让埃里克森得出结论：记忆行为与其说是一种直觉性的活动，不如说是一种认知性的活动。

Sentence 53

That’s because Congress has always envisioned joint federal-state immigration enforcement and explicitly encourages state officers to share information and cooperate with federal colleagues.

那是因为美国国会一直希望联邦政府能与州政府联合执行移民法案，并明确鼓励州政府官员与联邦政府的同事加强合作、信息共享。

Sentence 54

Ministers should also look at creating greater certainty in the rental environment, which would have a significant impact on the ability of registered providers to fund new developments from revenues.

部长们也应该考虑提高房屋租赁市场的稳定性，这对注册供应商从收入中拨出资金来进行新的开发会产生重大的影响。

Sentence 55

Such hijacked media are the opposite of earned media: an asset or campaign becomes hostage to consumers, other stakeholders, or activists who make negative allegations about a brand or product.

这种被操纵的媒体和免费媒体完全不同：一项资产或一场活动受那些对某个品牌或产品有不满说法的消费者、其他利益相关者或积极分子所左右。

Sentence 56

The policy follows similar efforts from other journals, after widespread concern that basic mistakes in data analysis are contributing to the irreproducibility of many published research findings.

这项政策效仿了与其他杂志类似的尝试，此前人们普遍担忧数据分析中的基本错误正导致许多已发表的研究结果无法被再现。

Sentence 57

They should exhibit strong interest and respect for whatever currently interests their fledgling adult （as naive or ill conceived as it may seem） while becoming a partner in exploring options for the future.

对当前让这些羽翼未丰的成年人感兴趣的任何事物（也许看上去很幼稚或欠考虑周全），父母都应该表现出强烈的兴趣和尊重，同时要成为他们的伙伴，与他们一起探索未来的选择。

Sentence 58

In other words, at a time when the working class has turned the country on its political head, frustrated that the opportunity that once defined America is vanishing, one obvious solution is staring us in the face.

换句话说，在工人阶级彻底改变这个国家的政治格局，对曾经使美国之所以成为美国的机会正在消失而感到沮丧的时候，一个显而易见的解决方案就摆在我们面前。

Sentence 59

Brain researchers have discovered that when we consciously develop new habits, we create parallel synaptic paths, and even entirely new brain cells, that can jump our trains of thought onto new, innovative tracks.

大脑研究人员发现，当我们有意识地培养新习惯的时候，大脑会创建出平行的突触路径，甚至是全新的脑细胞，这样可以使我们的思路跳转到全新的、创造性的轨道中。

Sentence 60

This type of integrity requires well-enforced laws in government transparency, such as records of official meetings, rules on lobbying, and information about each elected leader’s source of wealth.

这种廉政要求在政府透明度方面有严格执行的法律，如官方会议记录、游说规则以及每位当选领导人的财富来源的信息。

Sentence 61

In the past couple of weeks a quarrel has illustrated the value to advertisers of such fine-grained information: Should advertisers assume that people are happy to be tracked and sent behavioural ads?

在过去几周里，一场争论已经阐明了这种精确的信息对于广告商的价值：广告商是否可以认为用户愿意被追踪其在网络上的行为并接收基于他们在网络上的行为而制定的广告？

Sentence 62

Last year, the Transportation Security Administration （TSA） found in a secret check that undercover investigators were able to sneak weapons—both fake and real—past airport security nearly every time they tried.

去年，美国运输安全管理局，在一次秘密检查中发现，便衣调查员几乎每次尝试私携武器——无论是伪造的武器还是真的武器——都能顺利通过机场安检。

Sentence 63

California has asked the justices to refrain from a sweeping ruling, particularly one that upsets the old assumptions that authorities may search through the possessions of suspects at the time of their arrest.

加利福尼亚州已经要求法官们避免做出一刀切的裁决，尤其是不能做出那种颠覆了当局在逮捕嫌疑人时可以搜查其财产这些存在已久的假定的裁决。

Sentence 64

Priestly explains how the deep blue color of the assistant’s sweater descended over the years from fashion shows to department stores and to the bargain bin in which the poor girl doubtless found her garment.

普里斯特利解释了这位助理身上这件针织衫所采用的深蓝色这些年来是如何从时装秀没落到百货商店，最后沦落到商品打折处理区的，而这位可怜的女孩无疑是在那里淘到了这件衣服。

Sentence 65

If the district is essentially giving a pass to students who do not do their homework because of complicated family lives, it is going riskily close to the implication that standards need to be lowered for poor children.

如果该学区让那些因为家庭环境复杂而不做家庭作业的学生通过考试的话，那么这就危险地近乎于暗示着，对于贫穷的孩子，学业标准需要降低。

Sentence 66

The findings of a research institution have consistently shown that workers in all countries can be trained on the job to achieve radically higher productivity and, as a result, radically higher standards of living.

一所研究机构的研究结果一致表明，所有国家的工人都可以通过在岗培训，从根本上提高生产率，从而从根本上提高生活水平。

Sentence 67

Their analysis ruled out the possibility that it was firms’ political influence, rather than their CSR stand, that accounted for the leniency: Companies that contributed more to political campaigns did not receive lower fines.

他们的分析排除了这样的可能性，即：是公司的政治影响力，而非他们的企业社会责任立场让公司获得了宽大处理，因为那些支持政治运动更多的公司并没有被处以更少的罚金。

Sentence 68

The potential evolution of today’s technology, and its social consequences, is dazzlingly complicated, and it’s perhaps best left to science fiction writers and futurologists to explore the many possibilities we can envisage.

当今科技的潜在发展及其社会影响惊人地复杂，或许我们最好把诸多可能留给科幻作家和未来学家去探索。

Sentence 69

The company, a major energy supplier in New England, provoked justified outrage in Vermont last week when it announced it was reneging on a longstanding commitment to abide by the strict nuclear regulations.

当上周新英格兰地区的主要能源供应商宣布它将放弃遵守严格的核安全条例这一长期承诺时，该公司在佛蒙特州激起了民众无可厚非的愤怒。

Sentence 70

Of all the changes that have taken place in English-language newspapers during the past quarter-century, perhaps the most far-reaching has been the inexorable decline in the scope and seriousness of their arts coverage.

在过去的25年英文报纸所发生的变化中，影响最深远的可能是其艺术方面的报道在范围和严肃程度上都不可阻挡地下降了。

Sentence 71

Infants are wired to look at parents’ faces to try to understand their world, and if those faces are blank and unresponsive—as they often are when absorbed in a device—it can be extremely disconcerting for the children.

婴幼儿天生会观察父母的表情，试图理解他们的世界，如果父母的脸上毫无表情和反应——沉浸于电子设备时经常如此——这会让孩子们极其不安。

Sentence 72

Scientists have found that although we are prone to snap overreactions, if we take a moment and think about how we are likely to react, we can reduce or even eliminate the negative effects of our quick, hard-wired responses.

科学家们已经发现：虽然我们易于快速做出过度反应，但是如果我们花点时间考虑一下我们可能会做何反应，就可以减少，甚至是消除我们快速、本能的反应所带来的消极影响。

Sentence 73

Further arrangements—and there may be many—between the NHS and DeepMind will be carefully scrutinised to ensure that all necessary permissions have been asked of patients and all unnecessary data has been cleaned.

英国国民医疗服务体系（NHS）和DeepMind之间的进一步的协议——也许还有很多协议——将受到仔细审查，以确保从病人那里获得了所有必要的许可，以及所有不必要的数据都已被清除。

Sentence 74

Studies of both animals and humans have shown that sex hormones somehow affect the stress response, causing females under stress to produce more of the trigger chemicals than do males under the same conditions.

对动物和人类的研究表明：性激素会以某种方式影响应激反应，使处于压力下的雌性比处于相同条件下的雄性产生更多的能触发不良反应的化学物质。

Sentence 75

“Carry a book with you at all times” can actually work, too—providing you dip in often enough, so that reading becomes the default state from which you temporarily surface to take care of business, before dropping back down.

如果你能经常翻阅的话，“随时携带一本书”这种方式也能奏效，从而让阅读成为你的常态，你可以在需要处理事务的时候从书中暂时抽离出来，之后再重新开始阅读。

Sentence 76

Today, widespread social pressure to immediately go to college in conjunction with increasingly high expectations in a fast-moving world often causes students to completely overlook the possibility of taking a gap year.

如今，高中毕业后即刻升入大学这一普遍的社会压力，加之快速发展的世界对学生寄予越来越高的期望，这常常导致学生完全忽略了选择间隔年这一可能。

Sentence 77

It could be that we are evolving two communities of social scientists: one that is discipline-oriented and publishing in highly specialized journals, and one that is problem-oriented and publishing elsewhere, such as policy briefs.

这可能是因为我们发展出了两类社会科学家群体：一类是学科导向型并在高度专业的期刊上发表文章，另一类是问题导向型并在如政策简报等其他地方发表文章。

Sentence 78

Steelworkers, airline employees, and now those in the auto industry are joining millions of families who must worry about interest rates, stock market fluctuation, and the harsh reality that they may outlive their retirement money.

炼钢工人、航空公司职员，以及现在那些在汽车行业的员工都正在加入那些不得不担心利率、股市波动和退休金不够用这一残酷现实的数百万家庭的行列。

Sentence 79

After all, four decades of evidence has now shown that corporations in Europe as well as the US are evading the meritocratic hiring and promotion of women to top position—no matter how much “soft pressure” is put upon them.

毕竟四十年的事实现已表明，不管被施加多大的“软压力”，欧洲和美国的企业一直在回避英才管理制度，限制女性晋升到高层。

Sentence 80

His analysis should therefore end any self-contentedness among those who may believe that the global position of English is so stable that the young generation of the United Kingdom do not need additional language capabilities.

有些人可能认为英语的全球地位如此稳定以至于英国的年轻一代不需要获得额外的语言能力；他的分析应该会结束那些人的自满情绪。

Sentence 81

The Internet—and pressure from funding agencies, who are questioning why commercial publishers are making money from government-funded research by restricting access to it—is making access to scientific results a reality.

提供资金的机构施加压力，质疑为什么商业出版商可以通过限制人们查看政府资助的研究结果而从中牟利，来自这方面的压力和互联网正在使阅读科研结果成为现实。

Sentence 82

There is pressure for change from within the profession, but opponents of change among the regulators insist that keeping outsiders out of a law firm isolates lawyers from the pressure to make money rather than serve clients ethically.

在行业内部存在着改革的压力，但是监管部门中反对变革的人坚称，将外部人士排除在律师事务所之外，可以让律师远离赚钱的压力，从而遵守职业道德为委托人服务。

Sentence 83

The force of geographic conditions peculiar to America, the interplay of the varied national groups upon one another, and the sheer difficulty of maintaining old-world ways in a raw, new continent caused significant changes.

美国特有的地理条件的影响，不同民族之间的相互作用，以及在这片原始新大陆上维持旧有方式的困难，这些因素引起了重大的变化。

Sentence 84

Yet, when one looks at the photographs of the garden created by the homeless, it strikes one that, for all their diversity of styles, these gardens speak of various other fundamental urges, beyond that of decoration and creative expression.

然而，当人们看到那些无家可归者所创建的花园的照片时，受到了深深的震撼：尽管这些花园风格多样，但它们除了表现出创作者的装饰和创造力表达的需求之外，还表现出各种其他根本的需求。

Sentence 85

Under the plan, for example, the agency said it would not prosecute landowner or businesses that unintentionally kill, harm, or disturb the bird, as long as they had signed a range-wide management plan to restore prairie chicken habitat.

例如，根据此项计划，只要他们签署了一项大范围的管理计划来恢复小草原松鸡的栖息地，该管理局称其不会起诉那些无意杀死、伤害或干扰小草原松鸡的土地所有者或企业。

Sentence 86

In his article “How Intelligent Is Intelligence Testing?”, Sternberg notes that traditional tests best assess analytical and verbal skills but fail to measure creativity and practical knowledge, components also critical to problem solving and life success.

在斯腾伯格的文章《智力测试有多明智？》中，他指出传统的测试能最大程度地评估分析能力和语言表达能力，但不能衡量创造力和实践知识，这些部分对于解决问题和获得人生成功也极其重要。

Sentence 87

At a time when Thomas Piketty and other economists are warning of rising inequality and the increasing power of inherited wealth, it is bizarre that wealthy aristocratic families should still be the symbolic heart of modern democratic states.

在托马斯·皮凯蒂和其他经济学家提醒民众警惕不断加剧的不平等现象和不断增加的继承财富的权力时，这些富有的贵族家庭仍然是现代民主国家的象征性核心，这是很奇怪的。

Sentence 88

Calls to disassemble all telescopes on Mauna Kea or to ban future development there ignore the reality that astronomy and Hawaiian culture both seek to answer big questions about who we are, where we come from and where we are going.

拆除莫纳克亚山上所有的望远镜或禁止未来在那里新建望远镜的呼声忽略了这样一个事实，即天文学和夏威夷文化都在寻求关于“我们是谁”“我们来自哪里”“我们要去何处”这些重大问题的答案。

Sentence 89

Humans are unique in their capacity to not only make tools but then turn around and use them to create superfluous material goods—paintings, sculpture and architecture—and superfluous experiences—music, literature, religion and philosophy.

人类的独特之处在于，他们不仅有能力制造工具，而且还能反过来使用工具来创作额外的有形物品——绘画、雕塑和建筑——和额外的精神体验——音乐、文学、宗教和哲学。

Sentence 90

As a discovery claim works its way through the community, the interaction and confrontation between shared and competing beliefs about the science and the technology involved transforms an individual’s discovery claim into the community’s credible discovery.

当一个发现声明逐步通过科学界的审查时，与该科技相容和矛盾的观点就会相互作用和对抗，这样就会把个人的发现声明转变为科学界的可靠发现。

Sentence 91

But in her new book Join the Club, Tina Rosenberg contends that peer pressure can also be a positive force through what she calls the social cure, in which organizations and officials use the power of group dynamics to help individuals improve their lives and possibly the world.

但是，蒂娜·罗森堡在她的新书《加入俱乐部》中主张，同辈压力也可以通过她所说的“社会治疗”转化成一种积极的力量。在社会治疗的过程中，各机构及官员可以利用群体动力来帮助个人改善生活，甚至可能改善整个世界。

Sentence 92

Fundamentally, the USPS is in a historic squeeze between technological change that has permanently decreased demand for its bread-and-butter product, first-class mail, and a regulatory structure that denies management the flexibility to adjust its operations to the new reality.

从根本上说，美国邮政署（USPS）正处于一个历史性的困境之中，一方面是技术变革永久性地降低了对其主要产品——普通邮件的需求，另一方面是监管结构拒绝让管理部门灵活调整其业务以适应新形势。

Sentence 93

Unhappy parents rarely are provoked to wonder if they shouldn’t have had kids, but unhappy childless folks are bothered with the message that children are the single most important thing in the world: obviously their misery must be a direct result of the gaping baby-size holes in their lives.

几乎没有事情会促使不幸福的父母去琢磨自己是否不该养孩子，但是不幸福的且没有孩子的人们却总是被“孩子是世上唯一最重要的东西”这一信息所困扰：显然他们的不幸肯定是他们一生中没有孩子的缺憾造成的。

Sentence 94

To encourage innovation and competition, the report calls for increased investment in research, the crafting of coherent curricula that improve students’ ability to solve problems and communicate effectively in the 21st century, increased funding for teachers and the encouragement of scholars to bring their learning to bear on the great challenges of the day.

为了鼓励创新和竞争，报告呼吁增加对此项研究的投资，呼吁精心设计系统连贯的课程以提高学生在21世纪解决问题和有效沟通的能力，呼吁增加教师的经费，并鼓励学者应用他们的学识来应对当今巨大的挑战。

Sentence 95

Moreover, average overall margins are higher in wholesale than in retail; wholesale demand from the food service sector is growing quickly as more Europeans eat out more often; and changes in the competitive dynamics of this fragmented industry are at last making it feasible for wholesalers to consolidate.

此外，批发业的平均总利润高于零售业；随着越来越多的欧洲人更加频繁地外出就餐，餐饮服务业的批发需求也迅速增长；这一零散产业竞争力量的变化最终会使批发商们的联合成为可能。

Sentence 96

Just as bosses and boards have finally sorted out their worst accounting and compliance troubles, and improved their feeble corporation governance, a new problem threatens to earn them—especially in America—the sort of nasty headlines that inevitably lead to heads rolling in the executive suite: data insecurity.

就在老板和董事会终于处理好其最严重的财务和规章问题，改善了公司薄弱的管理之后，又一个新问题正威胁着他们——尤其是在美国——这个问题就是数据不安全性，这会让他们出现在令人不快的新闻头条中，将不可避免地使高层们受到严惩。

Sentence 97

The article is actually quite optimistic, as it outlines a potential solution to this problem, suggesting that an approach （which involves a one-hour, next-to-no-cost program） can close 63 percent of the achievement gap （measured by such factors as grades） between first-generation and other students.

这篇文章实际上相当乐观，因为它针对这个问题简要描述了一种可能的解决方案，表示有一种方式（一个耗时一小时、几乎零成本的项目）能够缩小第一代大学生和其他学生之间63%的成绩差距（以分数等指标衡量）。

Sentence 98

Precisely because readers from different historical periods, places and social experiences produce different but overlapping readings of the same words on the page—including for texts that engage with fundamental human concerns—debates about texts can play an important role in social discussion of beliefs and values.

正因为来自不同历史时期、不同地域和有着不同社会经历的读者会对页面上那些相同的文字产生不同但有重叠的解读——包括对涉及人类所关注的基本问题的文本解读，关于文本解读的争议才能在信仰和价值观的社会讨论中发挥重要作用。

Sentence 99

At Tulane University’s Tear Analysis Laboratory, Dr. Peter Kastl and his colleagues report that they can use tears to detect drug abuse and exposure to medication, to determine whether a contact lens fits properly or why it may be uncomfortable, to study the causes of “dry eye” syndrome and the effects of eye surgery, and perhaps even to measure exposure to environmental pollutants.

在杜兰大学的眼泪分析实验室，彼得·卡斯尔博士和他的同事报告称，他们可以用眼泪来检测出滥用毒品及使用药物的情况，确认隐形眼镜戴起来是否合适或者是戴着不舒适的原因，还能用来探究“干眼”综合征产生的原因和眼部手术的效果，也许甚至还能用来测量与环境污染物接触的情况。

Sentence 100

Young people who are still getting started in life were more likely than older adults to prioritize personal fulfillment in their work, to believe they will advance their careers most by regularly changing jobs, to favor communities with more public services and a faster pace of life, to agree that couples should be financially secure before getting married or having children, and to maintain that children are best served by two parents working outside the home, the survey found.

该调查发现，比起老年人，那些仍然处在生活起跑线的年轻人会更优先考虑他们在工作中的个人成就，更加认同通过定期换工作来推进个人职业生涯，更喜欢拥有较多公共服务的社区和节奏更快的生活，更坚信夫妻在结婚或者抚育孩子之前应该有经济上的保障，更主张父母双方都在外工作才能给孩子提供最好的生活。

缘起

分布式和日志暴增的场景下需要一个日志搜索工具

elasticsearch

安装

docker环境

1

Error response from daemon: manifest for elasticsearch:latest not found

kibana

elasticsearch可视化工具

参考文献

PTA1001总结

考点

• 字符串处理
• 输入输出

问题重述

c++

A_plus_B_Format.py

1
2
3
4
5
6
7
8

def summit():
    pass


if __name__ == '__main__':
    summit()

A_plus_B_Format.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

//
// Created by ednow on 2021/6/21.
//

#include <string>
#include "gtest/gtest.h"
#include <iostream>

using namespace std;


string solution(long long int A, long long int B) {
    long long int num = A + B;
    string S(to_string(abs(num)));
    unsigned long long len = S.length();

    while (len >= 4) {
        len -= 3;
        S.insert(len, ",");
    }

    if(num < 0) {
        S.insert(0, "-");
    }

    return S;
}


int summit(){
    long long int A=0, B=0;
    scanf("%lld %lld", &A, &B);
    cout << solution(A, B);
    return 0;
}


TEST(TestCase, test_PTA_1001) {
    ASSERT_EQ("-999,991", solution(-1000000, 9));
    ASSERT_EQ("0", solution(-1, 1));
    ASSERT_EQ("300", solution(300, 0));
    ASSERT_EQ("1,300", solution(1300, 0));
    ASSERT_EQ("-300", solution(-300, 0));
}

data.json

1

PTA1002总结

考点

• 字符串处理
• 输入输出

问题重述

python

一个正确答案

坑点1:

需要考虑到多项式的值为0的时候,输出为"0"不能有空格"0 "

测试数据中的某个测试点的输出格式错误的测试数据

坑点2:

记得考虑到所有的值都被round了

对应到我的代码中:这个地方也需要round

测试数据中的测试点1

思路

$\xrightarrow{\text{summit}}$读取输入的字符串$\xrightarrow{\text{rectify_data}}$得到的中间数据结构$\xrightarrow{\text{cal_poly}}$得到中间数据结构表示的计算的结果$\xrightarrow{\text{rectify_str}}$得到符合题目要求的正确结果$\xrightarrow{\text{summit}}$输出

语法技术

keys()不能进行+运算

sum的特殊用法

range() takes no keyword arguments

拓展阅读

四舍五入

python中四舍五入的特殊情况

参考文献2

A_plus_B_for_Polynomials.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

from typing import Dict


def rectify_str(_str: str) -> Dict:
    """
    给定一个题目定义的多项式字符串,将其放到一个dict中{幂:系数}
    :param _str: 题目定义的多项式字符串
    """
    result = {}
    numbers = _str[2:].split()
    for i in range(0, len(numbers) - 1, 2):
        result[int(numbers[i])] = float(numbers[i + 1])
    return result


def rectify_data(data: Dict) -> str:
    """
    将求解用的数据结构，转换为题目定义的多项式字符串
    :param data: 由{幂:系数}组成的Dict
    """
    data = {k: data[k] for k in sorted(data.keys(), reverse=True)}

    if len(data) > 0:
        numbers = map(
            lambda x: f'{x:.1f}' if isinstance(x, float) else str(x),
            sum(zip(data.keys(), data.values()), ())
        )
        return f"{len(data)} {' '.join(numbers)}"
    else:
        return "0"


def cal_poly(a: Dict, b: Dict) -> Dict:
    """
    计算两项多项式的和，结果保留1位小数
    :param a: 由{幂:系数}组成的Dict
    :param b: 由{幂:系数}组成的Dict
    """
    result = {}
    a_keys = list(a.keys())
    b_keys = list(b.keys())
    for e in set(a_keys + b_keys):
        if (e in a_keys) and (e in b_keys):
            c = a[e] + b[e]
            if c != 0:
                result[e] = c
        elif e in a_keys:
            if 0 != a[e]:
                result[e] = a[e]
        elif e in b_keys:
            if 0 != b[e]:
                result[e] = b[e]
    return result


def summit():
    print(rectify_data(cal_poly(rectify_str(input()), rectify_str(input()))), end='')


if __name__ == '__main__':
    summit()

A_plus_B_for_Polynomials.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//
// Created by ednow on 2021/6/23.
//

#include "algorithm"
#include "string"
#include <iostream>
#include "vector"
using namespace std;

typedef struct {
    long long int e; // 指数
    long long int c; // 系数
} number;

string solution(vector<number> A, vector<number> B){

    return "";
}

data.json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

[
  {
    "data": "2 1 2.4 0 3.2\n2 2 1.5 1 0.5",
    "answer": "3 2 1.5 1 2.9 0 3.2"
  },
  {
    "data": "1 2 -1\n1 2 1",
    "answer": "0",
    "description": "某个测试点的输出格式错误的测试数据"
  },
  {
    "data": "1 2 0\n1 1 -1",
    "answer": "1 1 -1.0",
    "description": "极端情况1, 解决了, 但未过测试点1"
  },
  {
    "data": "1 1 0\n1 2 0",
    "answer": "0",
    "description": "极端情况1, 解决了, 但未过测试点1"
  },
  {
    "data": "1 18446744073709551616 0.5\n1 18446744073709551616 0.5",
    "answer": "1 18446744073709551616 1.0",
    "description": "极端情况2, 64位整型溢出, 解决了, 但未过测试点1"
  },
  {
    "data": "1 1 0\n11 2 0.59",
    "answer": "1 2 0.6",
    "description": "测试点1"
  }
]

PTA1003总结

考点

• 图
• 最短路径
• Dijkstra
• 图
• 最短路径
• 无向图
• 带权图
• 全连通图
• 单源最短路径
• Dijkstra算法
• 邻接矩阵

问题重述

python

第一次提交

错误原因没有考虑经过$\color{green}{\text{前面一个点}}$到$\color{red}{\text{现在这个点}}$需要加上到$\color{green}{\text{前面一个点}}$的路径数（见data.json中的第三个测试数据）

第二次提交

去掉typing和unittest

包含typing和unittest

java

测试点情况

思路

做一次dijkstra，删一次路径

语法技术

拓展阅读

Emergency.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

from typing import Dict, List


def solution(graph: List[List[int]], source: int, destination: int, teams: Dict[int, int]) -> str:
    nodes = len(graph)
    infos = {
        "isVisited": [False] * nodes,  # 访问位
        "shortestLen": [float("inf")] * nodes,  # 最短路径的长度
        "parent": [None] * nodes,  # 最短路径的父亲节点
        "shortestNum": [0] * nodes,  # 多少条最短路径
        "maxTeams": [0] * nodes  # 最大的资源数
    }

    infos["isVisited"][source] = True  # 起点的访问位为True
    infos["shortestLen"][source] = 0  # 起点的最短路径的长度为0
    infos["maxTeams"][source] = teams[source]  # 起点的最大资源数为其自己的资源
    infos["shortestNum"][source] = 1  # 起点的最短路径为1，为了保证后面的逻辑能够正常运行

    # 现在扫描的节点
    now = source

    # 还有未访问的点
    while not all(infos["isVisited"]):
        # for i in zip(*infos) 转置的效率会怎么样
        # 扫描现在节点的邻居
        for neighbor in range(nodes):
            # 存在一条边
            if graph[now][neighbor] != 0 and not infos["isVisited"][neighbor]:
                temp = infos["shortestLen"][now] + graph[now][neighbor]
                if infos["shortestLen"][neighbor] > temp:  # 当前的路径更小，替换信息表中的路径
                    infos["shortestLen"][neighbor] = temp
                    totalTeams = infos["maxTeams"][now] + teams[neighbor]
                    if infos["maxTeams"][neighbor] < totalTeams:  # 如果这条最短路径上的物资更多
                        infos["maxTeams"][neighbor] = totalTeams
                    infos['parent'][neighbor] = now
                    infos["shortestNum"][neighbor] = infos["shortestNum"][now]  # 重置最短路径数
                    # 如果相等且已经访问，且这条路径和之前的最短路径不一样,最短路径数+1
                elif infos["shortestLen"][neighbor] == temp and infos["parent"][neighbor] != now:
                    infos["shortestNum"][neighbor] += infos["shortestNum"][now]
                    totalTeams = infos["maxTeams"][now] + teams[neighbor]
                    if infos["maxTeams"][neighbor] < totalTeams:  # 如果这条最短路径上的物资更多
                        infos["maxTeams"][neighbor] = totalTeams

        #  找到当前未访问且路径最短的节点
        minIdx = -1
        minWeight = float("inf")
        for i in range(nodes):
            if (infos["isVisited"][i] is False) and (infos["shortestLen"][i] < minWeight):
                minIdx = i
                minWeight = infos["shortestLen"][i]

        # 更新visited节点
        infos["isVisited"][minIdx] = True
        now = minIdx

    return f"{infos['shortestNum'][destination]} {infos['maxTeams'][destination]}"


def get_cities_roads_source_destination(string: str) -> List[int]:
    """
    :param string: "citiesNum roadsNum source destination"
    :return: [citiesNum, roadsNum, source, destination]
    """
    return list(map(int, string.split()))


def get_teams_size(string: str) -> Dict[int, int]:
    """
    :param string: "team1 team2 ... teamN"
    :return: {team_i: size}
    """
    return {
        idx: int(i) for idx, i in enumerate(string.split())
    }


def add_edge(graph: List[List[int]], string: str) -> None:
    """
    :param graph: 邻接矩阵表示的图
    :param string: "node1 node2 weight"
    """
    edge = list(map(int, string.split()))
    graph[edge[0]][edge[1]] = edge[2]
    graph[edge[1]][edge[0]] = edge[2]


def summit() -> str:
    cities,  roads, source, destination = get_cities_roads_source_destination(input())
    graph = [[0] * cities for _ in range(cities)]
    teams = get_teams_size(input())
    while roads > 0:
        add_edge(graph, input())
        roads -= 1
    print(solution(graph, source, destination, teams), end="\n")


if __name__ == '__main__':
    summit()

data.json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[
  {
    "data": "5 6 0 2\n1 2 1 5 3\n0 1 1\n0 2 2\n0 3 1\n1 2 1\n2 4 1\n3 4 1",
    "answer": "2 4"
  },
  {
    "data": "2 1 0 1\n1 2\n0 1 1",
    "answer": "1 3"
  },
  {
    "data": "7 11 0 2\n1 1 1 1 1 1 1\n0 1 2\n0 2 4\n0 3 1\n0 4 2\n1 2 2\n2 3 4\n2 5 1\n2 6 1\n3 4 1\n4 5 1\n4 6 1",
    "answer": "6 5"
  }
]

PTA1004总结

考点

• 树的层次遍历
• 树
• 树的遍历
• 层次遍历
• 孩子表示法

问题重述

The input ends with N being 0. That case must NOT be processed.?

c++

相较于java的动态特性，以及对c++的不熟悉，在设计树的数据结构的时候束手束脚的，加上pta1002超时的教训，意味着作为一种算法考试，为了规避超时，在延展性，设计性，优雅性上做出牺牲

在commit(#f2270f5)中进行了不好的设计(但貌似可以用时间换空间)，应该让栈去记录层数信息而不是让树这个数据结构本身去记录层数信息

结果

改进

只生成空vector

生成整个树的结构，不进行队列的操作

python

第一次提交

同样的思路,python好好的

果然没能好好掌握c++呢

第二次提交

CountingLeaves.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

import unittest
from typing import Dict, List, Tuple
import queue


def solution(tree: Dict[int, List[int]]) -> str:
    """
    :param tree: 孩子表示法：见readme
    :return:
    """
    q = queue.Queue()
    answer = dict()
    result = []
    childLevel = 0
    q.put((1, 1))  # 根节点进入队列,(节点编号，节点所在层号)
    # 进行层次遍历, 返回每一层的叶子节点数
    while not q.empty():
        head = q.get()  # 队列的头元素
        if len(tree[head[0]]) == 0:  # 检查头元素是不是叶子节点
            emptyNum = answer.get(head[1], 0)
            answer[head[1]] = emptyNum + 1  # 该层叶子节点数+1
        else:  # 让头元素的孩子节点进入队列
            childLevel = head[1] + 1
            for child in tree[head[0]]:
                q.put((child, childLevel))
    for i in range(1, childLevel+1):
        result.append(str(answer.get(i, 0)))
    if childLevel == 0:
        result = ["1"]
    return " ".join(result)


def get_nodes_and_not_leaves_num(string: str) -> List[int]:
    """
    :param string: "节点数 叶子节点数"
    :return: [节点数, 叶子节点数]
    """
    return list(map(int, string.split()))


def get_children(string: str) -> Tuple[int, List[int]]:
    """
    :param string: "ID K ID[1] ID[2] ... ID[K]"
    :return: 父亲节点，[ID[1] ID[2] ... ID[K]]
    """
    nodes = list(map(int, string.split()))
    return nodes[0], nodes[2:]


def summit() -> str:
    nodes, notLeaves = get_nodes_and_not_leaves_num(input())
    tree = {
        i: [] for i in range(nodes+1)
    }
    while notLeaves > 0:
        parent, children = get_children(input())
        tree[parent].extend(children)
        notLeaves -= 1
    print(solution(tree), end="\n")


if __name__ == '__main__':
    summit()

CountingLeaves.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//
// Created by ednow on 2021/6/25.
//
#include <fstream>
#include "gtest/gtest.h"
#include "nlohmann/json.hpp"
#include "utils.h"

#include "queue"
#include "map"
#include "list"
#include "vector"
using namespace std;

// 将int定义为long long int
//#define int long long int
// 一个树的数据结构
typedef vector<list<int>> Tree; // 树的孩子表示法
typedef struct queueItem {
    int label;
    int level;
}item; //{节点编号:层数}

// 进行层次遍历,返回每一层的叶子节点数
map<int,int>
solution(Tree & tree, int & childLevel){
    map<int, int> answer;
    queue<item> q;
//    int childLevel = 0;
    // 第一个节点在第一层
    item head = { .label = 1, .level = 1 };
    q.push(head); // 先push根节点进去
    while (!q.empty()) {
        head = q.front(); // 队列的头元素
        if (tree[head.label].empty()) { // 检查头元素是不是叶子节点
            answer[head.level]++; // 头元素所在层的叶子节点数+1
        }
        else { // 让头元素的孩子节点进入队列
            childLevel = head.level + 1;
            for (auto& child : tree[head.label]) {
                q.push(item{ .label = child, .level = childLevel });
            }
        }
        q.pop();
    }
    return answer;
}


string summit(){
    string s, name;
    char** end = nullptr;
    // N:节点数, M:非叶子节点的数量, parent:父亲节点的编号,label:孩子节点编号, children:孩子的数量
    int N = 0, M = 0, label = 0, parent = 0, children = 0, childLevel = 0;
    cin >> N >> M;
    //    scanf("%d %d", &N, &M);
    Tree tree = Tree(N + 1);
    while (M-- > 0) {
        cin >> name >> children;

        parent = strtol(name.c_str(), end, 10);
        do {
            cin >> name;
            label = strtol(name.c_str(), end, 10);
            tree[parent].push_back(label);
        } while (--children > 0); // 该节点还有孩子
    } ; // 还有非叶子节点

    map<int, int> answer = solution(tree, childLevel );
    if (answer.find(1) == answer.end()) {
        s += "0";
    }
    for (int i = 2; i <= childLevel; ++i) {
        if (answer.find(i) == answer.end()) {
            s += " 0";
        }
        else {
            s += " " + to_string(answer[i]);
        }

    }
    if (childLevel == 0)
    {
        s += "1";
    }
    return s;
}

int CountingLeavesMain(){
    cout << summit();
    return 0;
}

TEST(TestCase, test_PTA_1004) {
    using json = nlohmann::json;
    ifstream in("../PTA/PTA1004/data.json");
    json j;
    in >> j;
    for (auto & testcase :j) {
        cout << testcase["data"];
        string s = to_string(testcase["data"]);
        s = s.substr(1, s.length() - 2);
        replace_all_distinct(s, "\\n", " ");
        istringstream oss(s);
        cin.rdbuf(oss.rdbuf());
        ASSERT_EQ(testcase["answer"], summit());
    }
}

Slim.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

//
// Created by ednow on 2021/6/25.
//
#include "gtest/gtest.h"
#include "queue"
#include "map"
#include "list"
#include "vector"
#include <iostream>
#include <string>
using namespace std;

// 将int定义为long long int
//#define int long long int
// 一个树的数据结构
typedef vector<list<int>> Tree; // 树的孩子表示法
typedef struct queueItem {
    int label;
    int level;
}item; //{节点编号:层数}

int SlimMain() {
    string s, name;
    char** end = nullptr;
    // N:节点数, M:非叶子节点的数量, parent:父亲节点的编号,label:孩子节点编号, children:孩子的数量
    int N = 0, M = 0, label = 0, parent = 0, children = 0;
    cin >> N >> M;
    //    scanf("%d %d", &N, &M);
    Tree tree = Tree(N + 1);
    while (M-- > 0) {
        cin >> name >> children;

        parent = strtol(name.c_str(), end, 10);
        do {
            cin >> name;
            label = strtol(name.c_str(), end, 10);
            tree[parent].push_back(label);
        } while (--children > 0); // 该节点还有孩子
    } ; // 还有非叶子节点

    // 进行层次遍历
    map<int, int> answer;
    queue<item> q;
    int childLevel = 0;
    // 第一个节点在第一层
    item head = { .label = 1, .level = 1 };
    q.push(head); // 先push根节点进去
    while (!q.empty()) {
        head = q.front(); // 队列的头元素
        if (tree[head.label].empty()) { // 检查头元素是不是叶子节点
            answer[head.level]++; // 头元素所在层的叶子节点数+1
        }
        else { // 让头元素的孩子节点进入队列
            childLevel = head.level + 1;
            for (auto& child : tree[head.label]) {
                q.push(item{ .label = child, .level = childLevel });
            }
        }
        q.pop();
    }
    if (answer.find(1) == answer.end()) {
        s += "0";
    }
    for (int i = 2; i <= childLevel; ++i) {
        if (answer.find(i) == answer.end()) {
            s += " 0";
        }
        else {
            s += " " + to_string(answer[i]);
        }

    }
    if (childLevel == 0)
    {
        s += "1";
    }


    cout << s << endl;
    return 0;
}




//TEST(TestCase, test_PTA_1004_slim) {
//    Main();
//}

data.json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[
  {
    "data": "2 1\n01 1 02",
    "answer": "0 1"
  },
  {
    "data": "5 2\n01 3 02 03 05\n02 1 04",
    "answer": "0 2 1"
  },
  {
    "data": "1 0",
    "answer": "1"
  }
]

PTA1005总结

考点

• 字符串处理

• 输入输出

题目重述

python

第一次提交

问题需要解决

SpellItRight.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from typing import List


def summit():
    string = input()
    numToEn = {
        0: "zero",
        1: "one",
        2: "two",
        3: "three",
        4: "four",
        5: "five",
        6: "six",
        7: "seven",
        8: "eight",
        9: "nine",
    }
    nums: List[int] = [int(i) for i in string]
    print(" ".join([numToEn[int(i)] for i in str(sum(nums))]), end="")


if __name__ == '__main__':
    summit()

PTA1006总结

考点

• 字符串处理

• 输入输出

题目重述

python

第一次提交

原因(#284a809)的版本多加了个{}

第二次提交

用signIn 来计算SignOut了

SignInandSignOut.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

from typing import List


def extract_details(name: str, signIn: str, signOut: str):
    return {
        "name": name,
        "signIn": sum([60 ** (2 - idx) * int(i) for idx, i in enumerate(signIn.split(":"))]),
        "signOut": sum([60 ** (2 - idx) * int(i) for idx, i in enumerate(signOut.split(":"))]),
    }


def solution(memberInfos: List):
    unlock = f"{sorted(memberInfos, key=lambda x: x['signIn'])[0]['name']}"
    lock = f"{sorted(memberInfos, key=lambda x: x['signOut'])[-1]['name']}"

    return f"{unlock} {lock}"


def summit():
    memberInfos = []
    members = int(input())
    while members > 0:
        string = input()
        memberInfos.append(
            extract_details(*(string.split()))
        )
        members -= 1
    print(solution(memberInfos), end="")


if __name__ == '__main__':
    summit()

data.json

1
2
3
4
5
6
7
8
9
10

[
  {
    "data":"3\nCS301111 15:30:28 17:00:10\nSC3021234 08:00:00 11:25:25\nCS301133 21:45:00 21:58:40",
    "answer": "SC3021234 CS301133"
  },
  {
    "data":"3\na 00:00:00 12:00:00\nb 08:00:00 24:00:00\nc 21:45:00 21:58:40",
    "answer": "a b"
  }
]

PTA1007总结

考点

• 动态规划

问题重述

python

思路

${\textstyle\unicode{x2460}}$ 将一个[1,-1,2](data.json中id=32的测试数据),按照正负拆分为子列表[[1],[-1],[2]]。

$\color{red}{\text{正数列表}}$：[1],[2]
$\color{green}{\text{负数列表}}$:[-1]

${\textstyle\unicode{x2461}}$ 两个$\color{red}{\text{正数列表}}$中间有$\color{green}{\text{负数列表}}$的话肯定会让整个序列减少，但如果这三个列表的和（两个$\color{red}{\text{正数列表}}$中间有$\color{green}{\text{负数列表}}$）等于或大于另外两个$\color{red}{\text{正数列表}}$单独的和，那么合并这三个序列成更大的列表。

${\textstyle\unicode{x2462}}$ 处理完之后，找到最大的序列并,输出题目要求的内容。

将思路翻译成程序,并考虑边界情况。

第一次提交

第二次提交

通过data.json的1-6

第三次

通过data.json的所有测试

第四次

4

5

让merge_positive在result更新之后，记住merge的位置，不再从0开始扫描，不再TLE

6

发现原来是题目理解错了，他要求的不是最长的序列。$\color{red}{\text{读题很重要}}$

参考文献

解析

解析2

测试数据参考

解析3

MaximumSubsequenceSum.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

from typing import List
from functools import reduce


def next_positive_in_result(result: List[List[int]], now: int) -> int:
    """
    :param result:
    :param now: 现在指针的位置
    :return:
    """
    for i in range(now+1, len(result)):
        if sum(result[i]) >= 0:
            return i
    return -1


def split_positive_negative(nums: List[int]) -> List[List[int]]:
    result = []
    # 正负分割
    positive = False if nums[0] < 0 else True
    start = 0
    end = 0
    isChange = False
    for i in range(1, len(nums)):
        iPositive = False if nums[i] < 0 else True
        # 如果符号不相等
        if not(positive is iPositive):
            result.append(nums[start:i].copy())
            start = i
            positive = not positive
            isChange = True
    # if start == len(nums) - 1:  # 考虑最后一位
    result.append(nums[start:].copy())  # 帮前面的循环收尾
    if not isChange:  # 符号都一样
        return [nums]

    return result


def delete_zero_at_last(l: List[int]) -> None:
    if sum(l) == 0:  # 只有0不考虑
        return None
    while l[-1] == 0:
        del l[-1]


def merge_positive(result: List[List[int]]) -> None:
    # 试图合并正负序列
    isChange = False  # result列表有没有改变
    now = 0 if sum(result[0]) > 0 else next_positive_in_result(result, 0)
    while now != -1:
        nextPositiveIdx = next_positive_in_result(result, now)
        if nextPositiveIdx == -1:
            break
        merge = reduce(lambda a, b: a + sum(b), result[now:nextPositiveIdx+1], 0)
        if sum(result[now]) < merge and sum(result[nextPositiveIdx]) <= merge:  # 保证i最小
            result.insert(now, reduce(lambda a, b: a + b, result[now:nextPositiveIdx+1], []))
            del result[now+1:nextPositiveIdx+2]
            isChange = True
        else:
            isChange = False
            now = nextPositiveIdx
            nextPositiveIdx = next_positive_in_result(result, now)
        if isChange:
            now = nextPositiveIdx
            nextPositiveIdx = next_positive_in_result(result, now)


def find_max_sequence(result: List[List[int]]) -> int:
    maxIdx = 0
    for i in range(len(result)):
        if sum(result[i]) > sum(result[maxIdx]):
            maxIdx = i
    return maxIdx


def solution(nums: List[int]) -> str:
    """
    :param nums:
    :return: "maxSum maxSequenceFirstItem maxSequenceLastItem"
    """
    result = split_positive_negative(nums)
    if len(result) == 1 and sum(result[0]) <= 0:  # 全是负数
        return f"0 {result[0][0]} {result[0][-1]}"
    merge_positive(result)
    idx = find_max_sequence(result)
    # fix: id="24-2"
    delete_zero_at_last(result[idx])
    return f"{sum(result[idx])} {result[idx][0]} {result[idx][-1]}"


def summit():
    input()
    print(solution(list(map(int, input().split()))))


if __name__ == '__main__':
    summit()

data.json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183

[
  {
    "id": 1,
    "data": "10\n-10 1 2 3 4 -5 -23 3 7 -21",
    "answer": "10 1 4\n"
  },
  {
    "id": 2,
    "data": "10\n1 2 3",
    "answer": "6 1 3\n"
  },
  {
    "id": 3,
    "data": "10\n-1 -2 -3",
    "answer": "0 -1 -3\n"
  },
  {
    "id": 4,
    "data": "10\n1 -2 3",
    "answer": "3 3 3\n"
  },
  {
    "id": 5,
    "data": "10\n-1 -2 3",
    "answer": "3 3 3\n"
  },
  {
    "id": 6,
    "data": "10\n1 -2 -3",
    "answer": "1 1 1\n"
  },
  {
    "id": 7,
    "data": "10\n0",
    "answer": "0 0 0\n"
  },
  {
    "id": 8,
    "data": "10\n-1",
    "answer": "0 -1 -1\n"
  },
  {
    "id": 9,
    "data": "10\n1",
    "answer": "1 1 1\n"
  },
  {
    "id": 10,
    "data": "10\n1 1 0",
    "answer": "2 1 1\n"
  },
  {
    "id": 11,
    "data": "10\n0 0 0 0 0 0 0",
    "answer": "0 0 0\n"
  },
  {
    "id": 12,
    "data": "10\n-2 11 -4 13 -5 -2",
    "answer": "20 11 13\n"
  },
  {
    "id": 13,
    "data": "10\n-2 11 -4 13 -5 -2",
    "answer": "20 11 13\n"
  },
  {
    "id": 14,
    "data": "10\n0 -7 7 8",
    "answer": "15 7 8\n"
  },
  {
    "id": 15,
    "data": "10\n-10 0  7 -2 -1 8 4 -100 30 2",
    "answer": "32 30 2\n"
  },
  {
    "id": 16,
    "data": "10\n-10 1 2 3 4 -5 -23 3 7 -21",
    "answer": "10 1 4\n"
  },
  {
    "id": 17,
    "data": "10\n0 0 0 0 0 0 0 0 0 0",
    "answer": "0 0 0\n"
  },
  {
    "id": 18,
    "data": "10\n1 2 3 4 5 -1 -2 -3 -4 -5",
    "answer": "15 1 5\n"
  },
  {
    "id": 19,
    "data": "10\n-1 -2 -3 -4 -5",
    "answer": "0 -1 -5\n"
  },
    {
    "id": 20,
    "data": "10\n1 -2 3 4 -8 6 0 7 -9 10",
    "answer": "14 6 10\n"
  },
  {
     "id": 21,
    "data": "10\n-100 99 -300 200 -500",
    "answer": "200 200 200\n"
  },
  {
     "id": 22,
    "data": "10\n-100 -200 0 -300 -500",
    "answer": "0 0 0\n"
  },
  {
    "id": 23,
    "data": "11\n-10 1 2 3 -4 5 -10 7 -1 8 -9",
    "answer": "14 7 8\n"
  },
  {
    "id": 24,
    "data": "5\n-10 11 -5 -6 13",
    "answer": "13 11 13\n",
    "description": "保证最大，且i最小"
  },
  {
    "id": "24-2",
    "data": "5\n-10 11 -5 -6 13 0",
    "answer": "13 11 13\n",
    "description": "保证最大，且j最小，尾是0"
  },
  {
    "id": 25,
    "data": "5\n-1 1 -1 1 -1 1",
    "answer": "1 1 1\n"
  },
  {
    "id": 26,
    "data": "5\n0 -1 0 0 1 2",
    "answer": "3 0 2\n",
    "description": "最大和前面有一段是0"
  },
  {
    "id": 27,
    "data": "5\n0 -1 0 0 1 2 -1 1 0",
    "answer": "3 0 2\n",
    "description": "并列和对应相同i但是不同j，即尾是0"
  },
  {
    "id": 28,
    "data": "5\n5 4 -1 7 8",
    "answer": "23 5 8\n",
    "description": "https://leetcode.com/problems/maximum-subarray/"
  },
  {
      "id": 29,
      "data": "5\n-9 9 -9 -9 9",
      "answer": "9 9 9\n",
      "source": "https://blog.csdn.net/Joyceyang_999/article/details/81872970"
  },
  {
      "id": 30,
      "data": "5\n9 -9 -9 -9 9",
      "answer": "9 9 9\n",
      "source": "https://blog.csdn.net/Joyceyang_999/article/details/81872970"
  },
  {
      "id": 31,
      "data": "5\n0 9 -9 0 9",
      "answer": "9 0 9\n",
      "source": "https://blog.csdn.net/Joyceyang_999/article/details/81872970"
  },
  {
      "id": 32,
      "data": "5\n1 -1 2",
      "answer": "2 1 2\n",
      "description": "readme中的例子"
  },
  {
      "id": 32,
      "data": "5\n1 -1 2",
      "answer": "2 1 2\n",
      "description": "readme中的例子"
  }
]

PTA1008总结

考点

• 字符串处理

• 输入输出

问题重述

python

读题

第一个不是层数

Elevator.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def summit():
    string = input()
    result = 0
    q = list(map(int, string.split()))[1:]
    for now, destination in zip(([0]+q)[:-1], q):
        if now > destination:
            result += (now - destination) * 4
        else:
            result += (destination - now) * 6
        result += 5
    print(f"{result}", end="")


if __name__ == '__main__':
    summit()

data.json

1
2
3
4
5
6

[
  {
    "data":"3 2 3 1",
    "answer": "41"
  }
]

PTA1010总结

考点

• 查找
• 数论

问题重述

Given a pair of positive integers, for example, 6 and 110, can this equation 6 = 110 be true? The answer is yes, if 6 is a decimal number and 110 is a binary number.Now for any pair of positive integers $N_1$ and $N_2$, your task is to find the radix of one number while that of the other is given.

Input Specification:

Each input file contains one test case. Each case occupies a line which contains 4 positive integers:N1 N2 tag radixHere N1 and N2 each has no more than 10 digits. A digit is less than its radix and is chosen from the set { 0-9, a-z } where 0-9 represent the decimal numbers 0-9, and a-z represent the decimal numbers 10-35. The last number radix is the radix of N1 if tag is 1, or of N2 if tag is 2.

Output Specification:

For each test case, print in one line the radix of the other number so that the equation N1 = N2 is true. If the equation is impossible, print Impossible. If the solution is not unique, output the smallest possible radix.

Sample Input 1:

1

6 110 1 10

Sample Output 1:

1

2

Sample Input 2:

1

1 ab 1 2

Sample Output 2:

1

Impossible

要点复述

边界点

• 求出来的进制不合理
• 测试点11进制可以超过36

思路

可以参考2分法的做法
参考文献

参考文献

• tag直接对数ab交换即可

python

第一次提交

图片详情

无脑range会错的更多

图片详情

第二次提交

图片详情

第三次提交

图片详情

第四次提交

使用二分查找

图片详情

语法技术

Radix.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

from typing import Tuple


def num_to_decimal(num: str, radix: int) -> int:
    """
    将任意进制数转为10进制
    :param num:
    :param radix: 底
    """
    symbol_to_decimal = "0123456789abcdefghijklmnopqrstuvwxyz"
    result = 0
    for idx, i in enumerate(reversed(num)):
        # 测试点0：symbol不应该大于radix
        if symbol_to_decimal.index(i) >= radix:
            return -1
        result += symbol_to_decimal.index(i) * radix ** idx
    return result


def is_num_equal(num_radix_known: str, num_radix_unknown: str, radix: int) -> Tuple[bool, int]:
    """

    :param num_radix_known:
    :param num_radix_unknown:
    :param radix: num_radix_known的进制
    :return:
    """
    symbol_to_decimal = "0123456789abcdefghijklmnopqrstuvwxyz"
    is_equal = False
    num = num_to_decimal(num_radix_known, radix)

    min_radix = 0
    max_radix = num+1  # 记得+1测试点0
    while min_radix <= max_radix:
        mid_radix = int((min_radix + max_radix)/2)
        mid_num = num_to_decimal(num_radix_unknown, mid_radix)
        if mid_num == num:
            is_equal = True
            radix = mid_radix
            break

        if mid_num > num:
            max_radix = mid_radix - 1

        if mid_num < num:
            min_radix = mid_radix + 1

    # 测试点19
    if max(symbol_to_decimal.index(i)+1 for i in num_radix_unknown) > radix:
        is_equal = False
    return is_equal, radix


def summit():
    num1, num2, tag, radix = input().split()
    if int(tag) == 1:
        is_equal, radix = is_num_equal(num1, num2, int(radix))
    else:
        is_equal, radix = is_num_equal(num2, num1, int(radix))

    if is_equal:
        print(radix, end="")
    else:
        print("Impossible", end="")


if __name__ == '__main__':
    summit()

data.json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

[
  {
    "id": "1",
    "data": "6 110 1 10",
    "answer": "2",
    "description": "题目的样例"
  },
  {
    "id": "2",
    "data": "1 ab 1 2",
    "answer": "Impossible",
    "description": "题目的样例"
  },
  {
    "id": "0",
    "data": "6 110 2 2",
    "answer": "7",
    "description": "测试点0"
  },
  {
    "id": "3",
    "data": "120 1320 2 4",
    "answer": "10",
    "description": "测试点1"
  },
  {
    "id": "4",
    "data": "193602 3102 1 10",
    "answer": "40",
    "description": "测试点3"
  },
  {
    "id": "5",
    "data": "193602 3102 1 10",
    "answer": "40",
    "description": "测试点4"
  },
  {
    "id": "6",
    "data": "3102 2iug 1 40",
    "answer": "43",
    "description": "测试点5"
  },
  {
    "id": "7",
    "data": "2147483647 10 1 10",
    "answer": "2147483647",
    "description": "测试点7"
  },
  {
    "id": "8",
    "data": "abcd 3599a5 2 13",
    "answer": "50",
    "description": "测试点11"
  },
  {
    "id": "9",
    "data": "17 321 1 10",
    "answer": "Impossible",
    "description": "测试点19"
  }
]

PTA1011总结

考点

• 查找元素

问题重述

图片详情

没搞懂题目在干什么,但好像是每行套公式取最值

要点复述

边界点

思路

python

第一次提交

图片详情

语法技术

WorldCupBetting.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from functools import reduce


def summit():
    mapper = {
        0: "W",
        1: "T",
        2: "L"
    }
    maxOdds = []
    for _ in range(3):
        maxOdds.append(
            max(
                [(idx, float(i)) for idx, i in enumerate(input().split())],
                key=lambda x: x[1]
            )
        )
    print(f"{' '.join(mapper[x[0]] for x in maxOdds)} {(reduce(lambda a,b:a * b[1], maxOdds, 1)*0.65 - 1)*2:.2f}", end="")


if __name__ == '__main__':
    summit()

data.json

1
2
3
4
5
6
7
8

[
  {
    "id": "1",
    "data": "1.1 2.5 1.7\n1.2 3.1 1.6\n4.1 1.2 1.1",
    "answer": "T T W 39.31",
    "description": "题目的样例"
  }
]

PTA1012总结

考点

• 排序
• 排序

问题重述

图片详情

python

第一次提交

• 经研究发现是输出的时候超时了，在23行排序完没有超时(assert False)检查法

图片详情

第二次提交

• 测试点2是分数相同的情况下，排名要相同,参考文献

图片详情

第三次提交

• 感觉修复了第二次提交的bug？（但这种写法大数据下效率更高了？

图片详情

第四次提交

神坑！相同分数的人排名相同，但下一个新排位是他前面的人的数量！

图片详情

cpp

第一次提交

TheBestRank.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

from typing import Dict, List


def summit():
    studentsNum, checkNum = map(int, input().split())
    students: Dict[str, List[int]] = {}
    result = ""

    # 读入
    for _ in range(studentsNum):
        infos = input().split()
        students[infos[0]] = list(map(int, infos[1:]))
        students[infos[0]].insert(0, int(sum(students[infos[0]])/3))

    studentsItem = students.items()

    # 对每门学科各自排序
    rankA = list(dict(sorted(studentsItem, key=lambda x: x[1][0], reverse=True)).keys())
    rankC = list(dict(sorted(studentsItem, key=lambda x: x[1][1], reverse=True)).keys())
    rankM = list(dict(sorted(studentsItem, key=lambda x: x[1][2], reverse=True)).keys())
    rankE = list(dict(sorted(studentsItem, key=lambda x: x[1][3], reverse=True)).keys())

    # 对每一个请求输出最高排名, 排序优先级ACME
    ranks = [rankA, rankC, rankM, rankE]

    # 修正排名
    # _ranks = [{}] * 4:这样子每个的{}的索引都相同
    # rankId：第i类成绩，0：平均成绩，1：c语言，2：数学，3：英语
    _ranks = [{}, {}, {}, {}]
    for rankId, rank in enumerate(ranks):
        _ranks[rankId][rank[0]] = 1  # 让第一个排名第一
        compare = students[rank[0]][rankId]  # 获得第一个成绩
        rightRank = 1  # 真正的排名是1
        # idx：学生编号
        for num, idx in enumerate(rank[1:]):
            if compare == students[idx][rankId]:
                _ranks[rankId][idx] = rightRank  # 和上一个的排名相同
            else:
                compare = students[idx][rankId]
                rightRank = num + 2
                _ranks[rankId][idx] = rightRank

    ranks = _ranks

    mapper = {
        0: 'A',
        1: 'C',
        2: 'M',
        3: 'E'
    }
    for _ in range(checkNum):
        request = input()
        try:
            minIdx = min(enumerate(ranks), key=lambda x: x[1][request])[0]
            result += f"{ranks[minIdx][request]} {mapper[minIdx]}\n"
        except KeyError:  # 没有这号学生
            result += f"N/A\n"

    print(result, end='')


if __name__ == '__main__':
    summit()

example.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//
// Created by ednow on 2021/7/15.
//
#include <fstream>
#include "gtest/gtest.h"
#include "nlohmann/json.hpp"
#include "utils.h"

#include "iostream"
#include "ios"
#include "iomanip"
#include "vector"

#include<iostream>
#include<cstring>
#include<algorithm>
struct node{
    int id;
    //A C M E
    int grace[5];
    int rank[5];
}pre[2005];
int n,m;
using namespace std;
int tmp=0;
bool cmp(node x,node y){
    return x.grace [tmp]>y.grace [tmp];
}

int TheBestRank1(){
    cin>>n>>m;
    for(int i=0;i<n;i++){
        cin>>pre[i].id >>pre[i].grace [1]>>pre[i].grace [2]>>pre[i].grace [3];
        pre[i].grace [0]=(pre[i].grace [1]+pre[i].grace [2]+pre[i].grace [3])/3;
    }
    for(int i=0;i<4;i++){
        tmp=i;
        sort(pre,pre+n,cmp);
        for(int j=0;j<n;j++){
            pre[j].rank [i]=j+1;
        }
        for(int j=1;j<n;j++){
            if(pre[j].grace [i]==pre[j-1].grace[i])
                pre[j].rank [i]=pre[j-1].rank [i];
        }
    }
//	for(int i=0;i<n;i++){
//		cout<<pre[i].id <<endl;
//		for(int j=0;j<4;j++){
//			cout<<pre[i].rank [j]<<" ";
//		}
//		cout<<endl;
//	}
    char cp[5]={'A','C','M','E'};
    while(m--){
        int ID;
        cin>>ID;
        int Min=0;
        int tmp=0;
        bool flag=0;
        for(int i=0;i<n;i++){
            if(pre[i].id ==ID){
                flag=1;
                tmp=i;
                break;
            }
        }
        if(!flag){
            cout<<"N/A"<<endl;
            continue;
        }
        for(int i=1;i<4;i++){
            if(pre[tmp].rank [i]<pre[tmp].rank [Min]){
                Min=i;
            }
        }
        cout<<pre[tmp].rank [Min]<<" "<<cp[Min]<<endl;
    }
    return 0;
}

TEST(TestCase, test_PTA_1012_1) {
    using json = nlohmann::json;
    json j, config;
    ifstream in("../PTA/PTA1012/data.json");
    in >> j;
    ifstream configFile("../config.json");
    configFile >> config;
    vector<map<string, string>> testcases;
    //    &config
    copy_if (j.begin(), j.end(), std::back_inserter(testcases), [&](auto i){return i["id"]== config["testCaseId"];} );
    if (testcases.empty()){
        testcases = j.get<vector<map<string, string>>>();
    }
    for (auto & testcase :testcases) {
        cout << testcase["data"];
        string s = testcase["data"];
        replace_all_distinct(s, "\\n", " ");
        istringstream oss(s);
        cin.rdbuf(oss.rdbuf());  // 将测试用例读进cin
        std::stringstream   redirectStream;
        std::streambuf*     oldbuf  = std::cout.rdbuf( redirectStream.rdbuf() );
        TheBestRank1();
        ASSERT_EQ(testcase["answer"], redirectStream.str());
        std::cout.rdbuf(oldbuf);
    }
}